junebug12851 / pokered-game-database

const _ = require("lodash");

// Load dependency from Window if in a browser or from module if in NodeJS enviroment

let PokeredMonDB;

if(typeof window === "undefined")

else

    PokeredMonDB = window.PokeredMonDB.PokeredMonDB;

const monDB = new PokeredMonDB();

// Import Raw JSON Files

const eventPokemonRaw = require("./data/eventPokemon.json");

const eventsRaw = require("./data/events.json");

const hiddenCoinsRaw = require("./data/hiddenCoins.json");

const hiddenItemsRaw = require("./data/hiddenItems.json");

const mapsRaw = require("./data/maps.json");

const missablesRaw = require("./data/missables.json");

const randomNamesRaw = require("./data/randomNames.json");

const scriptsRaw = require("./data/scripts.json");

const spritesRaw = require("./data/sprites.json");

const starterCandidatesRaw = require("./data/starterCandidates.json");

const startersRaw = require("./data/starters.json");

const textCodesRaw = require("./data/textCodes.json");

const townsRaw = require("./data/towns.json");

const tradesRaw = require("./data/trades.json");

const trainersRaw = require("./data/trainers.json");

const worldScriptsRaw = require("./data/worldScripts.json");

// Class Constructor

// Initiate Array

const PokeredGameDB = exports.PokeredGameDB = function() {

    // Do initial build

    this.rebuild();

}

// Selectively inherit PokeredMonDB class properties as it's own uniquely

PokeredGameDB.prototype = _.cloneDeep(PokeredMonDB.prototype);

delete PokeredGameDB.prototype._processAllItems;

delete PokeredGameDB.prototype._processAllMoves;

delete PokeredGameDB.prototype._processAllPokemon;

delete PokeredGameDB.prototype._processEvolutionEntry;

delete PokeredGameDB.prototype.itemsRaw;

delete PokeredGameDB.prototype.movesRaw;

delete PokeredGameDB.prototype.typesRaw;

delete PokeredGameDB.prototype.pokemonRaw;

// Build or Rebuild database

// This should normally never need to be called manually

// and is provided for special edge cases. Keep in mind calling this again

// might create memory leaks in certain browsers due to circular references.

PokeredGameDB.prototype.rebuild = function() {

    //

    // Pass 1: Indexing, Cloning, and Setup

    //

    this._indexMaps();

    this._autoIndex(this.missablesRaw, "missables");

    this.events = _.cloneDeep(eventsRaw);

    this.randomNames = _.cloneDeep(randomNamesRaw);

    this._indexScripts();

    this._autoIndex(this.spritesRaw, "sprites");

    this._indexTextCodes();

    //

    // Pass 2: Processing

    //

    this._processEventPokemon();

    this._processHidden(this.hiddenCoinsRaw, "hiddenCoins");

    this._processHidden(this.hiddenItemsRaw, "hiddenItems");

    this.starterCandidates = _.cloneDeep(this.starterCandidatesRaw);

    this._processArrayDBEntry(this, "starterCandidates", monDB.pokemon);

    this.starters = _.cloneDeep(this.startersRaw);

    this._processArrayDBEntry(this, "starters", monDB.pokemon);

    this._processTowns();

    this._processTrades();

    this._processTrainers();

}

// Creates a 2nd index prefixed which just aliases the first index

// Only creates alias if key exists

PokeredGameDB.prototype._indexSecondaryPrefix = function(from, to, key, origKey, prefix) {

    if(prefix === undefined)

    this._iterate(from, function(entry) {

        if(entry[key] !== undefined)

    });

}

PokeredGameDB.prototype._indexMaps = function() {

    this.maps = [];

    this._indexPrimary(this.mapsRaw, this.maps, "ind");

    this._indexSecondary(this.mapsRaw, this.maps, "name", "ind");

    this._indexSecondarySnake(this.mapsRaw, this.maps, "name", "ind");

    this._indexSecondaryPrefix(this.mapsRaw, this.maps, "alias", "ind", "");

    this._indexSecondaryPrefix(this.mapsRaw, this.maps, "symbol", "ind", "");

}

PokeredGameDB.prototype._autoIndex = function(rv, vName) {

    const v = this[vName] = [];

    this._indexPrimary(rv, v, "ind");

    this._indexSecondary(rv, v, "name", "ind");

    this._indexSecondarySnake(rv, v, "name", "ind");

}

PokeredGameDB.prototype._indexTextCodes = function() {

    this.textCodes = [];

    this._indexPrimary(this.textCodesRaw, this.textCodes, "ind");

    this._indexSecondaryPrefix(this.textCodesRaw, this.textCodes, "name", "ind", "text");

}

PokeredGameDB.prototype._processTowns = function() {

    this._autoIndex(this.townsRaw, "towns");

    this._iterate(this.towns, function(val) {

        this._processPrimitiveDBEntry(val, "name", this.maps);

    });

}

PokeredGameDB.prototype._processTrades = function() {

    this.trades = [];

    const tradesRaw = this._addIndexes(this.tradesRaw);

    this._iterate(tradesRaw, function(val) {

        this._processPrimitiveDBEntry(val, "give", monDB.pokemon);

        this._processPrimitiveDBEntry(val, "get", monDB.pokemon);

    });

    this._indexPrimary(tradesRaw, this.trades, "ind");

    this._indexSecondaryPrefix(tradesRaw, this.trades, "_give", "ind", "give");

    this._indexSecondaryPrefix(tradesRaw, this.trades, "_get", "ind", "get");

    this._indexSecondaryPrefix(tradesRaw, this.trades, "nickname", "ind", "name");

}

PokeredGameDB.prototype._processEventPokemon = function() {

    const eventPokemonRaw = this._addIndexes(this.eventPokemonRaw);

    this.eventPokemon = [];

PokeredGameDB.prototype._processHidden = function(v, name) {

    const hiddenRaw = this._addIndexes(v);

    this[name] = [];

    this._iterate(hiddenRaw, function(val) {

        this._processPrimitiveDBEntry(val, "map", this.maps);

        this[name].push(val);

    });

}

PokeredGameDB.prototype._processTrainers = function() {

    const trainersRaw = _.cloneDeep(this.trainersRaw);

    this.trainers = [];

    this.trainers.ally = [];

    this.trainers.opp = [];

    this._iterate(trainersRaw, function(val) {

        const oppVal = _.cloneDeep(val);

        oppVal.ind += 200;

        oppVal.opponent = true;

        trainersRaw.push(oppVal);

    });

    this._indexPrimary(trainersRaw, this.trainers, "ind");

    this._iterate(this.trainers, function(val) {

        if(val.ind < 200) {

            this.trainers[val.name] = val;

            this.trainers[_.snakeCase(val.name)] = val;

            this.trainers.ally[val.name] = val;

            this.trainers.ally[_.snakeCase(val.name)] = val;

            this.trainers.ally[val.ind] = val;

        } else {

            this.trainers["Opponent " + val.name] = val;

            this.trainers[_.snakeCase("Opponent " + val.name)] = val;

            this.trainers.opp[val.name] = val;

            this.trainers.opp[_.snakeCase(val.name)] = val;

            this.trainers.opp[val.ind] = val;

        }

    });

}

PokeredGameDB.prototype._indexScripts = function() {

    const scriptsRaw = this._addIndexes(this.scriptsRaw);

    const worldScriptsRaw = _.cloneDeep(this.worldScriptsRaw);

    for(let i = 0; i < scriptsRaw.length; i++) {

        delete worldScriptsRaw[i].name;

        _.assign(scriptsRaw[i], worldScriptsRaw[i]);

    }

    this.scripts = [];

    this._indexPrimary(scriptsRaw, this.scripts, "ind");

    this._indexSecondary(scriptsRaw, this.scripts, "name", "ind");

    this._indexSecondarySnake(scriptsRaw, this.scripts, "name", "ind");

    this._indexSecondaryPrefix(scriptsRaw, this.scripts, "varName", "ind", "");

}

PokeredGameDB.prototype.getRandomName = function() {

    return _.sample(this.randomNames);

}

PokeredGameDB.prototype.getRandomStarterCandidate = function() {

    return _.sample(this.starterCandidates);

}

PokeredGameDB.prototype.getRandomStarter = function() {

    return _.sample(this.starters);

}

// Assigns Index Numbering

PokeredGameDB.prototype._addIndexes = function(from) {

    let i = 0;

    const ret = [];

    this._iterate(_.cloneDeep(from), function(val) {

        val.ind = i;

        ret.push(val);

        i++;

    });

    return ret;

}

// This interlinks primitive data to an existing db entry

PokeredGameDB.prototype._processPrimitiveDBEntry = function(value, from, where) {

    if(value[from] !== undefined && value["_" + from] === undefined) {

        value["_" + from] = value[from];

        value[from] = where[value[from]];

    }

}

// This loops over a simple array if it exists and inter-links valid elements to other data

PokeredGameDB.prototype._processArrayDBEntry = function(value, from, where) {

    if(value[from] !== undefined && value['_' + from] === undefined) {

        value['_' + from] = _.cloneDeep(value[from]);

        for(let i = 0; i < value[from].length; i++) {

            const val = value[from][i];

            value[from][i] = where[val];

        }

    }

}

// Add several ways to access the raw data, nothings duplicated because it's just all copying

// by reference

PokeredGameDB.eventPokemonRaw = PokeredGameDB.prototype.eventPokemonRaw = eventPokemonRaw;

PokeredGameDB.eventsRaw = PokeredGameDB.prototype.eventsRaw = eventsRaw;

PokeredGameDB.hiddenCoinsRaw = PokeredGameDB.prototype.hiddenCoinsRaw = hiddenCoinsRaw;

PokeredGameDB.hiddenItemsRaw = PokeredGameDB.prototype.hiddenItemsRaw = hiddenItemsRaw;

PokeredGameDB.mapsRaw = PokeredGameDB.prototype.mapsRaw = mapsRaw;

PokeredGameDB.missablesRaw = PokeredGameDB.prototype.missablesRaw = missablesRaw;

PokeredGameDB.randomNamesRaw = PokeredGameDB.prototype.randomNamesRaw = randomNamesRaw;

PokeredGameDB.scriptsRaw = PokeredGameDB.prototype.scriptsRaw = scriptsRaw;

PokeredGameDB.spritesRaw = PokeredGameDB.prototype.spritesRaw = spritesRaw;

PokeredGameDB.starterCandidatesRaw = PokeredGameDB.prototype.starterCandidatesRaw = starterCandidatesRaw;

PokeredGameDB.startersRaw = PokeredGameDB.prototype.startersRaw = startersRaw;

PokeredGameDB.textCodesRaw = PokeredGameDB.prototype.textCodesRaw = textCodesRaw;

PokeredGameDB.townsRaw = PokeredGameDB.prototype.townsRaw = townsRaw;

PokeredGameDB.tradesRaw = PokeredGameDB.prototype.tradesRaw = tradesRaw;

PokeredGameDB.trainersRaw = PokeredGameDB.prototype.trainersRaw = trainersRaw;

PokeredGameDB.worldScriptsRaw = PokeredGameDB.prototype.worldScriptsRaw = worldScriptsRaw;